export function in_array(search, array) {
	for (var i in array) {
		if (array[i] == search) return true
	}
	return false
}

export function isWechatBrowser() {
	// #ifdef H5	
	let ua = window.navigator.userAgent.toLowerCase()
	if (ua.match(/MicroMessenger/i) == 'micromessenger') {
		return true
	}
	// #endif
	return false
}




// 读取本地图片 Base64 内容
export function TaChooseImage(maxw = 500, count = 1, stype = ['album']) {
	return new Promise((resolve, reject) => {
		uni.chooseImage({
			fail: reject,
			count: count,
			sourceType: stype,
			complete: (res) => {
				(async (imgs) => {
					for (const filePath of res.tempFilePaths) {
						try {
							imgs.push(await TaImageToBase64(filePath, maxw))
						} catch (e) {
							return reject(e)
						}
					}
					resolve(count === 1 ? imgs[0] : imgs)
				})([])
			},
		})
	})
}

// 读取图片 Base64 内容
export function TaImageToBase64(file, maxw = 500) {
	return new Promise((resolve, reject) => {
		console.log(uni.compressImage);

		// #ifdef WEB
		let img = new Image()
		img.crossOrigin = 'Anonymous'
		img.onload = () => {
			let c = document.createElement('canvas')
			let w = img.naturalWidth,
				h = img.naturalHeight
			c.width = Math.min(maxw, w)
			c.height = c.width * (h / w)
			// @ts-ignore
			c.getContext('2d').drawImage(img, 0, 0, c.width, c.height)
			resolve(c.toDataURL('image/jpeg', 0.8))
		}
		img.src = file
		img.onerror = () => reject(new Error('Failed to load image'))
		// #endif


		// #ifdef MP-WEIXIN
		uni.compressImage({
			src: file,
			quality: 80,
			width: maxw + 'px',
			fail: (err) => {
				reject(err)
			},
			success: (res) => {
				resolve(res.tempFilePath)
				//readFileAsBase64(res.tempFilePath).then(resolve).catch(reject)
			}
		})
		// #endif

	})

	// 读取文件为 base64 格式
	function readFileAsBase64(file) {
		return new Promise((resolve, reject) => {
			let rd = new plus.io.FileReader()
			rd.onerror = (e) => reject(e)
			rd.onloadend = (v) => resolve(v.target.result)
			// @ts-ignore
			rd.readAsDataURL(plus.io.convertLocalFileSystemURL(file))
		})
	}
}
/**
 * 封装 uni.previewImage 方法，返回一个 Promise 对象
 * @param {Array<string>} urls - 需要预览的图片链接数组
 * @param {number} [current = 0] - 当前显示的图片索引，默认为 0
 * @returns {Promise<void>} - 一个 Promise 对象，预览成功时 resolve，失败时 reject
 */
export function previewImageWrapper(urls, current = 0) {
	// 检查 urls 是否为数组，如果不是则抛出错误
	if (!Array.isArray(urls)) {
		return Promise.reject(new Error('urls 参数必须是一个数组'));
	}
	// 检查 current 是否为有效的索引
	if (current < 0 || current >= urls.length) {
		return Promise.reject(new Error('current 参数超出了 urls 数组的有效范围'));
	}
	return new Promise((resolve, reject) => {
		uni.previewImage({
			urls,
			current,
			success: () => {
				resolve();
			},
			fail: (err) => {
				reject(err);
			}
		});
	});
}
export function getValueByPath(that, path) {
	// 将路径按 '.' 分割成数组
	const keys = path.split('.');
	// 逐级访问嵌套属性
	let result = that;
	for (const key of keys) {
		result = result[key];
		if (result === undefined) break; // 如果某一级不存在，直接返回 undefined
	}
	return result;
}



/**
 * 设置缓存（带有效期）
 * @param {string} key 缓存键名
 * @param {any} value 缓存值
 * @param {number} expire 有效期，单位：秒
 */
export function setCache(key, value, expire) {
	if (typeof expire !== 'number' || expire <= 0) {
		throw new Error('有效期必须是一个大于0的数字');
	}

	const cacheData = {
		value, // 缓存的值
		expire: Date.now() + expire * 1000, // 过期时间戳（当前时间 + 有效期）
	};

	// 将数据存入缓存
	uni.setStorageSync(key, JSON.stringify(cacheData));
}

/**
 * 获取缓存（带有效期检查）
 * @param {string} key 缓存键名
 * @returns {any | null} 返回缓存的值，如果过期或不存在则返回 null
 */
export function getCache(key) {
	const cacheDataStr = uni.getStorageSync(key);

	if (!cacheDataStr) {
		return null; // 缓存不存在
	}

	try {
		const cacheData = JSON.parse(cacheDataStr);

		// 检查是否过期
		if (Date.now() > cacheData.expire) {
			// 如果过期，清除缓存并返回 null
			uni.removeStorageSync(key);
			return null;
		}

		// 返回缓存的值
		return cacheData.value;
	} catch (error) {
		console.error('缓存解析失败', error);
		return null;
	}
}

/**
 * 清除指定缓存
 * @param {string} key 缓存键名
 */
export function removeCache(key) {
	uni.removeStorageSync(key);
}

/**
 * 清除所有缓存
 */
export function clearAllCache() {
	uni.clearStorageSync();
}
/**
 * 获取微信登录凭证（code）
 * @returns {Promise<string>} 返回一个 Promise，resolve 时返回 code
 */
export function getLoginCode() {
	return new Promise((resolve, reject) => {
		wx.login({
			success(res) {
				if (res.code) {
					// 获取 code 成功
					resolve(res.code);
				} else {
					// 获取 code 失败
					reject(new Error('获取登录凭证失败：' + res.errMsg));
				}
			},
			fail(err) {
				// 登录调用失败
				reject(new Error('登录调用失败：' + err.errMsg));
			},
		});
	});
}

export function getLoginCodeWithCache(anew = false) {
	return new Promise(async (resolve, reject) => {
		const cacheKey = 'wx_login_code';
		const expireTime = 300;
		if (!anew) {
			const cachedCode = getCache(cacheKey);
			if (cachedCode) {
				resolve(cachedCode);
			}
		}
		try {
			const code = await getLoginCode();
			setCache(cacheKey, code, expireTime);
			resolve(code);
		} catch (err) {
			reject(err);
		}
	});
}